home *** CD-ROM | disk | FTP | other *** search
/ Revolution - Das Atari CD Magazin 1997 / Revolution - Das Atari CD Magazin 1.iso / software / anwendng / qed_397 / sourcen / set.c < prev    next >
C/C++ Source or Header  |  1996-12-29  |  4KB  |  241 lines
  1. #include "global.h"
  2. #include "scroll.h"
  3. #include "set.h"
  4.  
  5. LOCAL UBYTE bits[]={128,64,32,16,8,4,2,1};
  6.  
  7. /*****************************************************************************/
  8.  
  9. WORD setfree(SET set)
  10. {
  11.     WORD    i;
  12.     ULONG help, h;
  13.  
  14.     h = 0xFFFFFFFFL;
  15.     for (i=0; i<SETMAX; i+=32)
  16.         if ((help=*set++)!=h)
  17.         {
  18.             h = 0x80000000L;
  19.             while (help>=h)
  20.             {
  21.                 i++; help<<=1;
  22.             }
  23.             break;
  24.         }
  25.     return i;
  26. }
  27.  
  28. /*****************************************************************************/
  29.  
  30. WORD setmax(SET set)
  31. {
  32.     WORD    i;
  33.     ULONG help;
  34.  
  35.     for (i=SETSIZE; (--i)>=0; )
  36.         if ((help=set[i])!=0L)
  37.         {
  38.             i *= 32;
  39.             for (i+=31; (help&1L)==0; i--,help>>=1) ;
  40.             return (i);
  41.         }
  42.     return -1;
  43. }
  44.  
  45. /*****************************************************************************/
  46.  
  47. WORD setmin(SET set)
  48. {
  49.     WORD    i;
  50.     ULONG help, h;
  51.  
  52.     for (i=0; i<SETMAX; i+=32)
  53.         if ((help=*set++)!=0L)
  54.         {
  55.             h = 0x80000000L;
  56.             while (help<h)
  57.             {
  58.                 i++; help<<=1;
  59.             }
  60.             break;
  61.         }
  62.     return i;
  63. }
  64.  
  65. /*****************************************************************************/
  66.  
  67. VOID setcpy (SET set1, const SET set2)
  68. {
  69.     COPYW (set1, set2, SETSIZE * (short) sizeof(ULONG));
  70. } /* setcpy */
  71.  
  72. /*****************************************************************************/
  73. #if (SETSIZE&1)!=0
  74.     So gehts nicht
  75. #endif
  76.  
  77. VOID setall (SET set)
  78. {
  79.     WORD i;
  80.  
  81.     i = SETSIZE/2;
  82.     while ((--i)>=0)
  83.     {
  84.         *set++ = 0xFFFFFFFFL;
  85.         *set++ = 0xFFFFFFFFL;
  86.     }
  87. } /* setall */
  88.  
  89. /*****************************************************************************/
  90.  
  91. VOID setclr (SET set)
  92. {
  93.     WORD i;
  94.  
  95.     i = SETSIZE/2;
  96.     while ((--i)>=0)
  97.     {
  98.         *set++ = 0L;
  99.         *set++ = 0L;
  100.     }
  101. } /* setclr */
  102.  
  103. /*****************************************************************************/
  104.  
  105. VOID setnot (SET set)
  106. {
  107.     WORD i;
  108.  
  109.     i = SETSIZE/2;
  110.     while ((--i)>=0)
  111.     {
  112.         *set++ ^= 0xFFFFFFFFL;
  113.         *set++ ^= 0xFFFFFFFFL;
  114.     }
  115. } /* setnot */
  116.  
  117. /*****************************************************************************/
  118.  
  119. VOID setand (SET set1, SET set2)
  120. {
  121.     WORD i;
  122.  
  123.     i = SETSIZE/2;
  124.     while ((--i)>=0)
  125.     {
  126.         *set1++ &= *set2++;
  127.         *set1++ &= *set2++;
  128.     }
  129. } /* setand */
  130.  
  131. /*****************************************************************************/
  132.  
  133. VOID setor (SET set1, SET set2)
  134. {
  135.     WORD i;
  136.  
  137.     i = SETSIZE/2;
  138.     while ((--i)>=0)
  139.     {
  140.         *set1++ |= *set2++;
  141.         *set1++ |= *set2++;
  142.     }
  143. } /* setor */
  144.  
  145. /*****************************************************************************/
  146.  
  147. VOID setxor (SET set1, SET set2)
  148. {
  149.     WORD i;
  150.  
  151.     i = SETSIZE/2;
  152.     while ((--i)>=0)
  153.     {
  154.         *set1++ ^= *set2++;
  155.         *set1++ ^= *set2++;
  156.     }
  157. } /* setxor */
  158.  
  159. /*****************************************************************************/
  160.  
  161. VOID setincl (SET set, WORD elt)
  162. {
  163.     if (elt>=0 && elt<=SETMAX)
  164.         *((UBYTE*)set+(elt>>3)) |= bits[elt&7];
  165. } /* setincl */
  166.  
  167. /*****************************************************************************/
  168.  
  169. VOID setexcl (SET set, WORD elt)
  170. {
  171.     if (elt>=0 && elt<=SETMAX)
  172.         *((UBYTE*)set+(elt>>3)) &= ~bits[elt&7];
  173. } /* setexcl */
  174.  
  175. /*****************************************************************************/
  176.  
  177. VOID setchg (SET set, WORD elt)
  178. {
  179.     if (elt>=0 && elt<=SETMAX)
  180.         *((UBYTE*)set+(elt>>3)) ^= bits[elt&7];
  181. }
  182.  
  183. /*****************************************************************************/
  184.  
  185. BOOLEAN setin (SET set, WORD elt)
  186. {
  187.     if (elt>=0 && elt<=SETMAX)
  188.         return ((*((UBYTE*)set+(elt>>3)) & bits[elt&7]) ? TRUE : FALSE);
  189.     else
  190.         return (FALSE);
  191. } /* setin */
  192.  
  193. /*****************************************************************************/
  194.  
  195. BOOLEAN setcmp (SET set1, SET set2)
  196. {
  197.     WORD i;
  198.  
  199.     if (set2==NULL)
  200.         for (i=0; i<SETSIZE && *set1++==0; i++);
  201.     else
  202.         for (i=0; i<SETSIZE && *set1++==*set2++; i++);
  203.     return (i==SETSIZE);
  204. } /* setcmp */
  205.  
  206. /*****************************************************************************/
  207.  
  208. WORD setcard (SET set)
  209. {
  210.     WORD i, card, max;
  211.  
  212.     max = setmax(set);
  213.     for (i=setmin(set), card=0; i<=max; i++)
  214.         if (setin (set, i)) card++;
  215.  
  216.     return (card);
  217. } /* setcard */
  218.  
  219. /*****************************************************************************/
  220.  
  221. VOID str2set (const UBYTE *str, SET set)
  222. {
  223.     WORD    i;
  224.  
  225.     setclr(set);
  226.     i = 0;
  227.     while(str[i])
  228.     {
  229.         if (str[i]=='-' && i>0)
  230.         {
  231.             UBYTE c;
  232.  
  233.             i++;
  234.             for (c=str[i-2]; c<str[i]; c++)
  235.                 setincl(set,c);
  236.         }
  237.         else
  238.             setincl(set,str[i++]);
  239.     }
  240. } /* str2set */
  241.